// HTTP请求封装

// 服务器API地址
const SERVER_URL = 'http://38.207.185.69:3000';
// const SERVER_URL = 'http://192.168.31.249:3000';

// 缓存和防重复请求配置
let whiteList = {
  '/roles/getAllRoles': 3000, // 3秒
  '/groups/getAllGroups': 3000 // 3秒
};

// 其他请求的缓存时间（1秒）
let otherCacheTime = 1000;

// 缓存存储
const cache = {};
// 请求锁 - 存储进行中的请求
const pendingRequests = {};

// 获取token
function getToken() {
  const userInfo = uni.getStorageSync('userInfo');
  return userInfo && userInfo.token ? userInfo.token : '';
}

/**
 * 发起请求
 * @param {Object} options - 请求选项
 * @param {string} options.url - 请求路径（不含服务器地址）
 * @param {string} options.method - 请求方法，默认为POST
 * @param {Object} options.data - 请求数据
 * @param {boolean} options.needToken - 是否需要携带token
 * @param {string} options.responseType - 响应类型
 * @param {Object} options.header - 请求头
 * @returns {Promise} 返回Promise
 */
function request(options) {
  const { url, method = 'POST', data = {}, needToken = true, responseType, header = {} } = options;
  
  // 构建完整URL
  const fullUrl = `${SERVER_URL}${url.startsWith('/') ? url : '/' + url}`;
  
  // 请求的路径（不含服务器地址）
  const path = url.startsWith('/') ? url : '/' + url;
  
  // 检查是否需要缓存的接口，如果不在白名单中则使用otherCacheTime
  const cacheTimeout = whiteList[path] !== undefined ? whiteList[path] : otherCacheTime;
  
  // 创建缓存key（结合URL和请求数据）
  const cacheKey = `${path}-${JSON.stringify(data)}`;
  
  // 返回Promise
  return new Promise((resolve, reject) => {
    // 检查缓存是否有效
    if (cache[cacheKey] && Date.now() - cache[cacheKey].timestamp < cacheTimeout) {
      // 返回缓存的结果
      return resolve(cache[cacheKey].data);
    }
    
    // 检查是否有相同请求正在进行中
    if (pendingRequests[cacheKey]) {
      // 等待第一个请求的结果
      return pendingRequests[cacheKey].then(resolve).catch(reject);
    }
    
    // 创建新的Promise并存储到pendingRequests
    pendingRequests[cacheKey] = new Promise((pendingResolve, pendingReject) => {
      performRequest(options, fullUrl, path, data, needToken, responseType, header, cacheKey, cacheTimeout)
        .then(result => {
          pendingResolve(result);
          resolve(result);
          // 请求完成后删除pendingRequest记录
          delete pendingRequests[cacheKey];
        })
        .catch(error => {
          pendingReject(error);
          reject(error);
          // 请求完成后删除pendingRequest记录
          delete pendingRequests[cacheKey];
        });
    });
  });
}

/**
 * 执行实际的请求
 */
function performRequest(options, fullUrl, path, data, needToken, responseType, header, cacheKey, cacheTimeout) {
  // 构建请求数据
  const requestData = { ...data };
  
  // 创建请求头
  const requestHeader = { ...header };
  
  // 如果需要携带token，添加到请求头中
  if (needToken) {
    const token = getToken();
    if (token) {
      requestHeader['Authorization'] = `Bearer ${token}`;
    }
  }
  
  return new Promise((resolve, reject) => {
    uni.request({
      url: fullUrl,
      method: options.method || 'POST',
      data: requestData,
      responseType,
      header: requestHeader,
      success: (res) => {
        // 用户相关API
        if (path.startsWith('/user/')) {
          if (res.statusCode === 200 && res.data.code === 200) {
            // 如果需要缓存，保存结果
            if (cacheKey && cacheTimeout) {
              cache[cacheKey] = {
                data: res.data,
                timestamp: Date.now()
              };
            }
            resolve(res.data);
          } else {
            reject({
              code: res.data.code || res.statusCode,
              message: res.data.message || '请求失败'
            });
          }
        } 
        // 其他API使用errCode/errMsg
        else {
          if (res.statusCode === 200 && res.data.errCode === 0) {
            // 如果需要缓存，保存结果
            if (cacheKey && cacheTimeout) {
              cache[cacheKey] = {
                data: res.data,
                timestamp: Date.now()
              };
            }
            resolve(res.data);
          } else {
            reject({
              errCode: res.data.errCode || 'REQUEST_FAILED',
              errMsg: res.data.errMsg || '请求失败'
            });
          }
        }
      },
      fail: (err) => {
        // 用户相关API
        if (path.startsWith('/user/')) {
          reject({
            code: 'REQUEST_FAILED',
            message: '请求失败: ' + (err.errMsg || JSON.stringify(err))
          });
        } 
        // 其他API使用errCode/errMsg
        else {
          reject({
            errCode: 'REQUEST_FAILED',
            errMsg: '请求失败: ' + (err.errMsg || JSON.stringify(err))
          });
        }
      }
    });
  });
}

export default {
  request,
  getToken,
  SERVER_URL
}; 